home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_gwu / predef3.c < prev    next >
C/C++ Source or Header  |  1996-01-30  |  6KB  |  216 lines
  1. /*
  2.  * Copyright (C) 1985-1992  New York University
  3.  * 
  4.  * This file is part of the Ada/Ed-C system.  See the Ada/Ed README file for
  5.  * warranty (none) and distribution info and also the GNU General Public
  6.  * License for more details.
  7.  
  8.  */
  9.  
  10. /*    +---------------------------------------------------+
  11.       |                                                   |
  12.       |          I N T E R P     P R E D E F S            |
  13.       |            Part 3: Utility Procedures             |
  14.       |                  (C Version)                      |
  15.       |                                                   |
  16.       |   Adapted From Low Level SETL version written by  |
  17.       |                                                   |
  18.       |                  Monte Zweben                     |
  19.       |               Philippe Kruchten                   |
  20.       |               Jean-Pierre Rosen                   |
  21.       |                                                   |
  22.       |    Original High Level SETL version written by    |
  23.       |                                                   |
  24.       |                   Clint Goss                      |
  25.       |               Tracey M. Siesser                   |
  26.       |               Bernard D. Banner                   |
  27.       |               Stephen C. Bryant                   |
  28.       |                  Gerry Fisher                     |
  29.       |                                                   |
  30.       |              C version written by                 |
  31.       |                                                   |
  32.       |               Robert B. K. Dewar                  |
  33.       |                                                   |
  34.       +---------------------------------------------------+
  35. */
  36.  
  37. /*  This module contains routines for the implementation of some of
  38.  *  the predefined Ada packages and routines, namely SEQUENTIAL_IO,
  39.  *  DIRECT_IO, TEXT_IO, and CALENDAR. Part 3 contains utility routines
  40.  *  for access to paramerters on the stack and for returning values.
  41.  */
  42.  
  43. #include <stdlib.h>
  44. #ifdef IBM_PC
  45. #include <string.h>
  46. #else
  47. #include <strings.h>
  48. #endif
  49. #include "ipredef.h"
  50. #include "intcp.h"
  51. #include "predefp.h"
  52.  
  53.  
  54. /* GET_ARGUMENT_PTR */
  55.  
  56. /* Procedure to get argument address. The parameter is the offset from the
  57.  * TOS to the base/offset entry. The corresponding pointer is returned.
  58.  */
  59.  
  60. int *get_argument_ptr(int offset)                      /*;get_argument_addr*/
  61. {
  62.     return ADDR(TOSM(offset + 1), TOSM(offset));
  63. }
  64.  
  65.  
  66. /* GET_STRING_VALUE */
  67.  
  68. /* Procedure to get argument value of type string. The parameter is the offset
  69.  * from the TOS to the entry for the string (consisting of a descriptor and a
  70.  * value. The string value is converted from internal Ada form to standard C
  71.  * form and stored in work_string.
  72.  */
  73.  
  74. void get_string_value(int offset)                       /*;get_string_value*/
  75. {
  76.     int     displ, a_base, size;
  77.     char   *cp;
  78.     int    *ip;
  79.  
  80.     displ = TOSM(offset);       /* base + offset of template address */
  81.     a_base = TOSM(offset + 1);
  82.     size = SIZE(ADDR(a_base, displ));
  83.  
  84.     displ = TOSM(offset + 2);   /* base + offset of array */
  85.     a_base = TOSM(offset + 3);
  86.  
  87.     ip = ADDR(a_base, displ);
  88.     cp = work_string;
  89.     while(size--)
  90.         *cp++ = *ip++;
  91.     *cp++ = 0;
  92. }
  93.  
  94.  
  95. /* MAKE_STRING */
  96.  
  97. /* This procedure takes the string in work_string, allocates a block to hold
  98.  * it and then copies the string to this block, returning its address. The
  99.  * caller should eventually free this space using predef_free.
  100.  */
  101.  
  102. char *make_string()                                              /*;make_string*/
  103. {
  104.     char   *s;
  105.  
  106.     s = predef_alloc(strlen(work_string) + 1);
  107.     strcpy(s, work_string);
  108.     return s;
  109. }
  110.  
  111. /* GET_ARGUMENT_VALUE */
  112.  
  113. /* Procedure to get argument value of type int. The parameter is the offset
  114.  * from the TOS to the base/offset address. The integer value stored at this
  115.  * address is returned as the result.
  116.  */
  117.  
  118. int get_argument_value(int offset)                     /*;get_argument_value*/
  119. {
  120.     return *ADDR(TOSM(offset + 1), TOSM(offset));
  121. }
  122.  
  123. /* GET_FLOAT_ARGUMENT_VALUE */
  124.  
  125. /* Procedure to get argument value of type float. The parameter is the offset
  126.  * from the TOS to the base/offset address. The float value stored at this
  127.  * address is returned as the result.
  128.  */
  129.  
  130. float get_float_argument_value(int offset)         /*;get_float_argument_value*/
  131. {
  132.     return *((float *)(ADDR(TOSM(offset + 1), TOSM(offset))));
  133. }
  134.  
  135. /* GET_LONG_ARGUMENT_VALUE */
  136.  
  137. /* Procedure to get argument value of type long. The parameter is the offset
  138.  * from the TOS to the base/offset address. The long value stored at this
  139.  * address is returned as the result.
  140.  */
  141.  
  142. long get_long_argument_value(int offset)           /*;get_long_argument_value*/
  143. {
  144.     return *((long *)(ADDR(TOSM(offset + 1), TOSM(offset))));
  145. }
  146.  
  147.  
  148. /* GET_FILENUM */
  149.  
  150. /* Get an integer value using the base and offset values on top of the
  151.  * stack and store the result in filenum.
  152.  */
  153.  
  154. void get_filenum()                                              /*;get_filenum */
  155. {
  156.     filenum = *ADDR(TOSM(1),TOS);
  157. }
  158.  
  159.  
  160. /* GET_FILE_ARGUMENT_OR_DEFAULT */
  161.  
  162. /* Retrieves file argument if necessary, else provides default file.
  163.  * Sets file_offset to 2 if there is a file argument, 0 otherwise.
  164.  * The PREDEF operation codes are arranged so that range tests can be
  165.  * used to determine whether or not a file argument is present, and
  166.  * if not, whether the default file is the current in or out file.
  167.  */
  168.  
  169. void get_file_argument_or_default()         /*;get_file_argument_or_default*/
  170. {
  171.     if (operation <= P_P_FILE) {
  172.         filenum = *ADDR(TOSM(1),TOS);
  173.         file_offset = 2;
  174.     }
  175.     else {
  176.         filenum = (operation <= P_P_IN) ? current_in_file : current_out_file;
  177.         file_offset = 0;
  178.     }
  179. }
  180.  
  181.  
  182. /* RETURN_STRING */
  183.  
  184. /* S is a C string that is first converted to an Ada string. The parameter
  185.  * param_off is the offset in the stack where the place holder begins. Puts
  186.  * on the stack necessary information to return string s. Used by functions
  187.  * which return a string result.
  188.  */
  189.  
  190. void return_string(char *s, int param_off)                    /*;return_string*/
  191. {
  192.     int     length, i;
  193.     int     bse, off;
  194.     int    *ptr;
  195.  
  196.     length = strlen(s);
  197.     create(length, &bse, &off, &ptr);
  198.  
  199.     for (i = 0; i < length; i++) {
  200.         *ptr++ = *s++;
  201.     }
  202.  
  203.     TOSM(param_off + 3) = bse;
  204.     TOSM(param_off + 2) = off;
  205.  
  206.     create(WORDS_S_ARRAY, &bse, &off, &ptr);
  207.     S_ARRAY(ptr) -> ttype = TT_S_ARRAY;
  208.     S_ARRAY(ptr) -> object_size = length;
  209.     S_ARRAY(ptr) -> index_size = 1;
  210.     S_ARRAY(ptr) -> salow = 1;
  211.     S_ARRAY(ptr) -> sahigh = length;
  212.  
  213.     TOSM(param_off + 1) = bse;
  214.     TOSM(param_off) = off;
  215. }
  216.